package a.i;

import a.c.d;
import a.c.e;
import a.c.i;
import a.c.j;
import a.c.k;
import a.c.n;
import a.c.x;

import java.util.HashMap;
import java.util.Map;

public class db
{
  public static int a;
  
  public static x a(double[] paramArrayOfDouble)
  {
    return new a_(paramArrayOfDouble, null, null, null);
  }
  
  public static x a(int[] paramArrayOfInt)
  {
    return new a_(null, paramArrayOfInt, null, null);
  }
  
  public static x a(boolean[] paramArrayOfBoolean)
  {
    return new a_(null, null, paramArrayOfBoolean, null);
  }
  
  public static x a(Object[] paramArrayOfObject)
  {
    return new a_(null, null, null, paramArrayOfObject);
  }
  
  public static x a(double[] paramArrayOfDouble, int[] paramArrayOfInt, boolean[] paramArrayOfBoolean, Object[] paramArrayOfObject)
  {
    return new a_(paramArrayOfDouble, paramArrayOfInt, paramArrayOfBoolean, paramArrayOfObject);
  }
  
  public static n b(double[] paramArrayOfDouble)
  {
    return new b_(paramArrayOfDouble, null, null, null);
  }
  
  public static n b(int[] paramArrayOfInt)
  {
    return new b_(null, paramArrayOfInt, null, null);
  }
  
  public static n b(boolean[] paramArrayOfBoolean)
  {
    return new b_(null, null, paramArrayOfBoolean, null);
  }
  
  public static n b(Object[] paramArrayOfObject)
  {
    return new b_(null, null, null, paramArrayOfObject);
  }
  
  public static n b(double[] paramArrayOfDouble, int[] paramArrayOfInt, boolean[] paramArrayOfBoolean, Object[] paramArrayOfObject)
  {
    return new b_(paramArrayOfDouble, paramArrayOfInt, paramArrayOfBoolean, paramArrayOfObject);
  }
  
  public static x a()
  {
    return new d_(new HashMap());
  }
  
  public static x a(Map paramMap)
  {
    return new d_(paramMap);
  }
  
  public static n b()
  {
    return new d_(new HashMap());
  }
  
  public static n b(Map paramMap)
  {
    return new d_(paramMap);
  }
  
  public static j c()
  {
    return c(new HashMap());
  }
  
  public static j c(Map paramMap)
  {
    return new d_(paramMap);
  }
  
  public static final class e_
    implements x, n
  {
    private int a;
    private final k b;
    private final i c;
    private boolean d;
    private Boolean e;
    public static int f;
    
    public e_(j paramj, boolean paramBoolean)
    {
      this(paramj, paramj, paramBoolean);
    }
    
    public e_(k paramk, i parami, boolean paramBoolean)
    {
      this.b = paramk;
      this.c = parami;
      a(paramBoolean);
    }
    
    public void a(boolean paramBoolean)
    {
      this.d = paramBoolean;
      this.e = (paramBoolean ? Boolean.TRUE : Boolean.FALSE);
      this.a += 1;
    }
    
    public Object get(Object paramObject)
    {
      boolean bool = p.b;
      a_ locala_ = (a_)this.b.get(paramObject);
      if (!bool) {
        if (locala_ == null) {
          return this.e;
        }
      }
      if (!bool) {
        if (locala_.a != this.a) {
          return this.e;
        }
      }
      return locala_.b ? Boolean.TRUE : Boolean.FALSE;
    }
    
    public void a(Object paramObject1, Object paramObject2)
    {
      a(paramObject1, ((Boolean)paramObject2).booleanValue());
    }
    
    public boolean getBool(Object paramObject)
    {
      boolean bool = p.b;
      a_ locala_ = (a_)this.b.get(paramObject);
      if (!bool) {
        if (locala_ == null) {
          return this.d;
        }
      }
      if (!bool) {
        if (locala_.a != this.a) {
          return this.d;
        }
      }
      return locala_.b;
    }
    
    public double getDouble(Object paramObject)
    {
      throw new UnsupportedOperationException();
    }
    
    public int getInt(Object paramObject)
    {
      throw new UnsupportedOperationException();
    }
    
    public void a(Object paramObject, boolean paramBoolean)
    {
      boolean bool = p.b;
      a_ locala_1 = (a_)this.b.get(paramObject);
      if (!bool) {
        if (locala_1 == null)
        {
          a_ locala_2 = new a_();
          locala_2.b = paramBoolean;
          locala_2.a = this.a;
          this.c.a(paramObject, locala_2);
          if (!bool) {
            if (!p.a) {
              return;
            }
          }
        }
        else
        {
          locala_1.b = paramBoolean;
        }
      }
      locala_1.a = this.a;
    }
    
    public void a(Object paramObject, double paramDouble)
    {
      throw new UnsupportedOperationException();
    }
    
    public void a(Object paramObject, int paramInt)
    {
      throw new UnsupportedOperationException();
    }
    
    static final class a_
    {
      public int a;
      public boolean b;
    }
  }
  
  public static final class g_
    implements x, n
  {
    private int a;
    private final i b;
    private final k c;
    private int d;
    private Integer e;
    public static int f;
    
    public g_(j paramj, int paramInt)
    {
      this(paramj, paramj, paramInt);
    }
    
    public g_(k paramk, i parami, int paramInt)
    {
      this.c = paramk;
      this.b = parami;
      a(paramInt);
    }
    
    public void a(int paramInt)
    {
      this.d = paramInt;
      this.e = new Integer(paramInt);
      this.a += 1;
    }
    
    public Object get(Object paramObject)
    {
      a_ locala_ = (a_)this.c.get(paramObject);
      if (!p.b) {
        if (locala_ == null) {
          return this.e;
        }
      }
      if (locala_.a != this.a) {
        return this.e;
      }
      return new Integer(locala_.b);
    }
    
    public void a(Object paramObject1, Object paramObject2)
    {
      a(paramObject1, ((Number)paramObject2).intValue());
    }
    
    public boolean getBool(Object paramObject)
    {
      throw new UnsupportedOperationException();
    }
    
    public double getDouble(Object paramObject)
    {
      return getInt(paramObject);
    }
    
    public int getInt(Object paramObject)
    {
      boolean bool = p.b;
      a_ locala_ = (a_)this.c.get(paramObject);
      if (!bool) {
        if (locala_ == null) {
          return this.d;
        }
      }
      if (!bool) {
        if (locala_.a != this.a) {
          return this.d;
        }
      }
      return locala_.b;
    }
    
    public void a(Object paramObject, boolean paramBoolean)
    {
      throw new UnsupportedOperationException();
    }
    
    public void a(Object paramObject, double paramDouble)
    {
      throw new UnsupportedOperationException();
    }
    
    public void a(Object paramObject, int paramInt)
    {
      boolean bool = p.b;
      a_ locala_1 = (a_)this.c.get(paramObject);
      if (!bool) {
        if (locala_1 == null)
        {
          a_ locala_2 = new a_();
          locala_2.b = paramInt;
          locala_2.a = this.a;
          this.b.a(paramObject, locala_2);
          if (!bool) {
            if (!p.a) {
              return;
            }
          }
        }
        else
        {
          locala_1.b = paramInt;
        }
      }
      locala_1.a = this.a;
    }
    
    static final class a_
    {
      public int a;
      public int b;
    }
  }
  
  public static final class f_
    implements x, n
  {
    private int a;
    private final k b;
    private final i c;
    private double d;
    private Double e;
    public static boolean f;
    
    public f_(j paramj, double paramDouble)
    {
      this(paramj, paramj, paramDouble);
    }
    
    public f_(k paramk, i parami, double paramDouble)
    {
      this.b = paramk;
      this.c = parami;
      a(paramDouble);
    }
    
    public void a(double paramDouble)
    {
      this.d = paramDouble;
      this.e = new Double(paramDouble);
      this.a += 1;
    }
    
    public Object get(Object paramObject)
    {
      a_ locala_ = (a_)this.b.get(paramObject);
      if (!p.b) {
        if (locala_ == null) {
          return this.e;
        }
      }
      if (locala_.a != this.a) {
        return this.e;
      }
      return new Double(locala_.b);
    }
    
    public void a(Object paramObject1, Object paramObject2)
    {
      a(paramObject1, ((Number)paramObject2).doubleValue());
    }
    
    public boolean getBool(Object paramObject)
    {
      throw new UnsupportedOperationException();
    }
    
    public double getDouble(Object paramObject)
    {
      boolean bool = p.b;
      a_ locala_ = (a_)this.b.get(paramObject);
      if (!bool) {
        if (locala_ == null) {
          return this.d;
        }
      }
      if (!bool) {
        if (locala_.a != this.a) {
          return this.d;
        }
      }
      return locala_.b;
    }
    
    public int getInt(Object paramObject)
    {
      return (int)Math.rint(getDouble(paramObject));
    }
    
    public void a(Object paramObject, boolean paramBoolean)
    {
      throw new UnsupportedOperationException();
    }
    
    public void a(Object paramObject, double paramDouble)
    {
      boolean bool = p.b;
      a_ locala_1 = (a_)this.b.get(paramObject);
      if (!bool) {
        if (locala_1 == null)
        {
          a_ locala_2 = new a_();
          locala_2.b = paramDouble;
          locala_2.a = this.a;
          this.c.a(paramObject, locala_2);
          if (!bool) {
            if (!p.a) {
              return;
            }
          }
        }
        else
        {
          locala_1.b = paramDouble;
        }
      }
      locala_1.a = this.a;
    }
    
    public void a(Object paramObject, int paramInt)
    {
      a(paramObject, paramInt);
    }
    
    static final class a_
    {
      public int a;
      public double b;
    }
  }
  
  public static final class h_
    implements x, n
  {
    private int a;
    private final k b;
    private final i c;
    private Object d;
    public static int e;
    
    public h_(j paramj, Object paramObject)
    {
      this(paramj, paramj, paramObject);
    }
    
    public h_(k paramk, i parami, Object paramObject)
    {
      this.b = paramk;
      this.c = parami;
      a(paramObject);
    }
    
    public void a(Object paramObject)
    {
      this.d = paramObject;
      this.a += 1;
    }
    
    public Object get(Object paramObject)
    {
      boolean bool = p.b;
      a_ locala_ = (a_)this.b.get(paramObject);
      if (!bool) {
        if (locala_ == null) {
          return this.d;
        }
      }
      if (!bool) {
        if (locala_.a != this.a)
        {
          locala_.b = null;
          return this.d;
        }
      }
      return locala_.b;
    }
    
    public void a(Object paramObject1, Object paramObject2)
    {
      boolean bool = p.b;
      a_ locala_1 = (a_)this.b.get(paramObject1);
      if (!bool) {
        if (locala_1 == null)
        {
          a_ locala_2 = new a_();
          locala_2.b = paramObject2;
          locala_2.a = this.a;
          this.c.a(paramObject1, locala_2);
          if (!bool) {
            if (!p.a) {
              return;
            }
          }
        }
        else
        {
          locala_1.b = paramObject2;
        }
      }
      locala_1.a = this.a;
    }
    
    public boolean getBool(Object paramObject)
    {
      throw new UnsupportedOperationException();
    }
    
    public double getDouble(Object paramObject)
    {
      throw new UnsupportedOperationException();
    }
    
    public int getInt(Object paramObject)
    {
      throw new UnsupportedOperationException();
    }
    
    public void a(Object paramObject, boolean paramBoolean)
    {
      a(paramObject, paramBoolean ? Boolean.TRUE : Boolean.FALSE);
    }
    
    public void a(Object paramObject, double paramDouble)
    {
      a(paramObject, new Double(paramDouble));
    }
    
    public void a(Object paramObject, int paramInt)
    {
      a(paramObject, new Integer(paramInt));
    }
    
    static final class a_
    {
      public int a;
      public Object b;
    }
  }
  
  static class d_
    extends db.c_
    implements j, x, n
  {
    d_(Map paramMap)
    {
      super();
    }
    
    public void a(Object paramObject1, Object paramObject2)
    {
      this.a.put(paramObject1, paramObject2);
    }
    
    public void a(Object paramObject, int paramInt)
    {
      this.a.put(paramObject, new Integer(paramInt));
    }
    
    public void a(Object paramObject, double paramDouble)
    {
      this.a.put(paramObject, new Double(paramDouble));
    }
    
    public void a(Object paramObject, boolean paramBoolean)
    {
      this.a.put(paramObject, paramBoolean ? Boolean.TRUE : Boolean.FALSE);
    }
  }
  
  static class c_
    implements k
  {
    Map a;
    
    c_(Map paramMap)
    {
      this.a = paramMap;
    }
    
    public Object get(Object paramObject)
    {
      return this.a.get(paramObject);
    }
    
    public int getInt(Object paramObject)
    {
      Object localObject = this.a.get(paramObject);
      if (!p.b) {}
      return (localObject instanceof Number) ? ((Number)localObject).intValue() : 0;
    }
    
    public double getDouble(Object paramObject)
    {
      Object localObject = this.a.get(paramObject);
      return (p.b) || ((localObject instanceof Number)) ? ((Number)localObject).doubleValue() : 0.0D;
    }
    
    public boolean getBool(Object paramObject)
    {
      return Boolean.TRUE.equals(this.a.get(paramObject));
    }
  }
  
  private static final class b_
    implements n
  {
    double[] a;
    int[] b;
    boolean[] c;
    Object[] d;
    
    b_(double[] paramArrayOfDouble, int[] paramArrayOfInt, boolean[] paramArrayOfBoolean, Object[] paramArrayOfObject)
    {
      this.a = paramArrayOfDouble;
      this.b = paramArrayOfInt;
      this.c = paramArrayOfBoolean;
      this.d = paramArrayOfObject;
    }
    
    public Object get(Object paramObject)
    {
      boolean bool = p.b;
      try
      {
        return this.d[((d)paramObject).d()];
      }
      catch (ClassCastException localClassCastException)
      {
        throw new IllegalArgumentException("Argument must be of type Edge.");
      }
      catch (NullPointerException localNullPointerException)
      {
        if (!bool) {
          if (paramObject == null) {
            throw new IllegalArgumentException("Argument must be non-null.");
          }
        }
        if (((bool) || ((paramObject instanceof d))) && (((d)paramObject).c() == null)) {
          throw new IllegalArgumentException("Argument is not in graph");
        }
        throw new UnsupportedOperationException("Cannot get Object from this type of Map!");
      }
    }
    
    public double getDouble(Object paramObject)
    {
      boolean bool = p.b;
      try
      {
        return this.a[((d)paramObject).d()];
      }
      catch (ClassCastException localClassCastException)
      {
        throw new IllegalArgumentException("Argument must be of type Edge.");
      }
      catch (NullPointerException localNullPointerException)
      {
        if (!bool) {
          if (paramObject == null) {
            throw new IllegalArgumentException("Argument must be non-null.");
          }
        }
        if (((bool) || ((paramObject instanceof d))) && (((d)paramObject).c() == null)) {
          throw new IllegalArgumentException("Argument is not in graph");
        }
        throw new UnsupportedOperationException("Cannot get double from this type of Map!");
      }
    }
    
    public int getInt(Object paramObject)
    {
      boolean bool = p.b;
      try
      {
        return this.b[((d)paramObject).d()];
      }
      catch (ClassCastException localClassCastException)
      {
        throw new IllegalArgumentException("Argument must be of type Edge.");
      }
      catch (NullPointerException localNullPointerException)
      {
        if (!bool) {
          if (paramObject == null) {
            throw new IllegalArgumentException("Argument must be non-null.");
          }
        }
        if (((bool) || ((paramObject instanceof d))) && (((d)paramObject).c() == null)) {
          throw new IllegalArgumentException("Argument is not in graph");
        }
        throw new UnsupportedOperationException("Cannot get int from this type of Map!");
      }
    }
    
    public boolean getBool(Object paramObject)
    {
      boolean bool = p.b;
      try
      {
        return this.c[((d)paramObject).d()];
      }
      catch (ClassCastException localClassCastException)
      {
        throw new IllegalArgumentException("Argument must be of type Edge.");
      }
      catch (NullPointerException localNullPointerException)
      {
        if (!bool) {
          if (paramObject == null) {
            throw new IllegalArgumentException("Argument must be non-null.");
          }
        }
        if (((bool) || ((paramObject instanceof d))) && (((d)paramObject).c() == null)) {
          throw new IllegalArgumentException("Argument is not in graph");
        }
        throw new UnsupportedOperationException("Cannot get boolean from this type of Map!");
      }
    }
    
    public void a(Object paramObject1, Object paramObject2)
    {
      boolean bool = p.b;
      try
      {
        this.d[((d)paramObject1).d()] = paramObject2;
      }
      catch (ClassCastException localClassCastException)
      {
        throw new IllegalArgumentException("Key must be of type Edge.");
      }
      catch (NullPointerException localNullPointerException)
      {
        if (!bool) {
          if (paramObject1 == null) {
            throw new IllegalArgumentException("Key must be non-null.");
          }
        }
        if (((bool) || ((paramObject1 instanceof d))) && (((d)paramObject1).c() == null)) {
          throw new IllegalArgumentException("Key is not in graph");
        }
        throw new UnsupportedOperationException("Cannot set Object in this type of Map!");
      }
    }
    
    public void a(Object paramObject, double paramDouble)
    {
      boolean bool = p.b;
      try
      {
        this.a[((d)paramObject).d()] = paramDouble;
      }
      catch (ClassCastException localClassCastException)
      {
        throw new IllegalArgumentException("Key must be of type Edge.");
      }
      catch (NullPointerException localNullPointerException)
      {
        if (!bool) {
          if (paramObject == null) {
            throw new IllegalArgumentException("Key must be non-null.");
          }
        }
        if (((bool) || ((paramObject instanceof d))) && (((d)paramObject).c() == null)) {
          throw new IllegalArgumentException("Key is not in graph");
        }
        throw new UnsupportedOperationException("Cannot set double in this type of Map!");
      }
    }
    
    public void a(Object paramObject, int paramInt)
    {
      boolean bool = p.b;
      try
      {
        this.b[((d)paramObject).d()] = paramInt;
      }
      catch (ClassCastException localClassCastException)
      {
        throw new IllegalArgumentException("Key must be of type Edge.");
      }
      catch (NullPointerException localNullPointerException)
      {
        if (!bool) {
          if (paramObject == null) {
            throw new IllegalArgumentException("Key must be non-null.");
          }
        }
        if (((bool) || ((paramObject instanceof d))) && (((d)paramObject).c() == null)) {
          throw new IllegalArgumentException("Key is not in graph");
        }
        throw new UnsupportedOperationException("Cannot set int in this type of Map!");
      }
    }
    
    public void a(Object paramObject, boolean paramBoolean)
    {
      boolean bool = p.b;
      try
      {
        this.c[((d)paramObject).d()] = paramBoolean;
      }
      catch (ClassCastException localClassCastException)
      {
        throw new IllegalArgumentException("Key must be of type Edge.");
      }
      catch (NullPointerException localNullPointerException)
      {
        if (!bool) {
          if (paramObject == null) {
            throw new IllegalArgumentException("Key must be non-null.");
          }
        }
        if (((bool) || ((paramObject instanceof d))) && (((d)paramObject).c() == null)) {
          throw new IllegalArgumentException("Key is not in graph");
        }
        throw new UnsupportedOperationException("Cannot set boolean in this type of Map!");
      }
    }
  }
  
  static final class a_
    implements x
  {
    double[] a;
    int[] b;
    boolean[] c;
    Object[] d;
    
    a_(double[] paramArrayOfDouble, int[] paramArrayOfInt, boolean[] paramArrayOfBoolean, Object[] paramArrayOfObject)
    {
      this.a = paramArrayOfDouble;
      this.b = paramArrayOfInt;
      this.c = paramArrayOfBoolean;
      this.d = paramArrayOfObject;
    }
    
    public Object get(Object paramObject)
    {
      boolean bool = p.b;
      try
      {
        return this.d[((e)paramObject).f()];
      }
      catch (ClassCastException localClassCastException)
      {
        throw new IllegalArgumentException("Argument must be of type Node.");
      }
      catch (NullPointerException localNullPointerException)
      {
        if (!bool) {
          if (paramObject == null) {
            throw new IllegalArgumentException("Argument must be non-null.");
          }
        }
        if (((bool) || ((paramObject instanceof e))) && (((e)paramObject).g() == null)) {
          throw new IllegalArgumentException("Argument is not in graph");
        }
        throw new UnsupportedOperationException("Cannot get Object from this type of Map!");
      }
    }
    
    public double getDouble(Object paramObject)
    {
      boolean bool = p.b;
      try
      {
        return this.a[((e)paramObject).f()];
      }
      catch (ClassCastException localClassCastException)
      {
        throw new IllegalArgumentException("Argument must be of type Node.");
      }
      catch (NullPointerException localNullPointerException)
      {
        if (!bool) {
          if (paramObject == null) {
            throw new IllegalArgumentException("Argument must be non-null.");
          }
        }
        if (((bool) || ((paramObject instanceof e))) && (((e)paramObject).g() == null)) {
          throw new IllegalArgumentException("Argument is not in graph");
        }
        throw new UnsupportedOperationException("Cannot get double from this type of Map!");
      }
    }
    
    public int getInt(Object paramObject)
    {
      boolean bool = p.b;
      try
      {
        return this.b[((e)paramObject).f()];
      }
      catch (ClassCastException localClassCastException)
      {
        throw new IllegalArgumentException("Argument must be of type Node.");
      }
      catch (NullPointerException localNullPointerException)
      {
        if (!bool) {
          if (paramObject == null) {
            throw new IllegalArgumentException("Argument must be non-null.");
          }
        }
        if (((bool) || ((paramObject instanceof e))) && (((e)paramObject).g() == null)) {
          throw new IllegalArgumentException("Argument is not in graph");
        }
        throw new UnsupportedOperationException("Cannot get int from this type of Map!");
      }
    }
    
    public boolean getBool(Object paramObject)
    {
      boolean bool = p.b;
      try
      {
        return this.c[((e)paramObject).f()];
      }
      catch (ClassCastException localClassCastException)
      {
        throw new IllegalArgumentException("Argument must be of type Node.");
      }
      catch (NullPointerException localNullPointerException)
      {
        if (!bool) {
          if (paramObject == null) {
            throw new IllegalArgumentException("Argument must be non-null.");
          }
        }
        if (((bool) || ((paramObject instanceof e))) && (((e)paramObject).g() == null)) {
          throw new IllegalArgumentException("Argument is not in graph");
        }
        throw new UnsupportedOperationException("Cannot get boolean from this type of Map!");
      }
    }
    
    public void a(Object paramObject1, Object paramObject2)
    {
      boolean bool = p.b;
      try
      {
        this.d[((e)paramObject1).f()] = paramObject2;
      }
      catch (ClassCastException localClassCastException)
      {
        throw new IllegalArgumentException("Key must be of type Node.");
      }
      catch (NullPointerException localNullPointerException)
      {
        if (!bool) {
          if (paramObject1 == null) {
            throw new IllegalArgumentException("Key must be non-null.");
          }
        }
        if (((bool) || ((paramObject1 instanceof e))) && (((e)paramObject1).g() == null)) {
          throw new IllegalArgumentException("Key is not in graph");
        }
        throw new UnsupportedOperationException("Cannot set Object in this type of Map!");
      }
    }
    
    public void a(Object paramObject, double paramDouble)
    {
      boolean bool = p.b;
      try
      {
        this.a[((e)paramObject).f()] = paramDouble;
      }
      catch (ClassCastException localClassCastException)
      {
        throw new IllegalArgumentException("Key must be of type Node.");
      }
      catch (NullPointerException localNullPointerException)
      {
        if (!bool) {
          if (paramObject == null) {
            throw new IllegalArgumentException("Key must be non-null.");
          }
        }
        if (((bool) || ((paramObject instanceof e))) && (((e)paramObject).g() == null)) {
          throw new IllegalArgumentException("Key is not in graph");
        }
        throw new UnsupportedOperationException("Cannot set double in this type of Map!");
      }
    }
    
    public void a(Object paramObject, int paramInt)
    {
      boolean bool = p.b;
      try
      {
        this.b[((e)paramObject).f()] = paramInt;
      }
      catch (ClassCastException localClassCastException)
      {
        throw new IllegalArgumentException("Key must be of type Node.");
      }
      catch (NullPointerException localNullPointerException)
      {
        if (!bool) {
          if (paramObject == null) {
            throw new IllegalArgumentException("Key must be non-null.");
          }
        }
        if (((bool) || ((paramObject instanceof e))) && (((e)paramObject).g() == null)) {
          throw new IllegalArgumentException("Key is not in graph");
        }
        throw new UnsupportedOperationException("Cannot set int in this type of Map!");
      }
    }
    
    public void a(Object paramObject, boolean paramBoolean)
    {
      boolean bool = p.b;
      try
      {
        this.c[((e)paramObject).f()] = paramBoolean;
      }
      catch (ClassCastException localClassCastException)
      {
        throw new IllegalArgumentException("Key must be of type Node.");
      }
      catch (NullPointerException localNullPointerException)
      {
        if (!bool) {
          if (paramObject == null) {
            throw new IllegalArgumentException("Key must be non-null.");
          }
        }
        if (((bool) || ((paramObject instanceof e))) && (((e)paramObject).g() == null)) {
          throw new IllegalArgumentException("Key is not in graph");
        }
        throw new UnsupportedOperationException("Cannot set boolean in this type of Map!");
      }
    }
  }
}



/* Location:           E:\idea\

 * Qualified Name:     a.i.db

 * JD-Core Version:    0.7.0.1

 */